home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 142 / Gekkan Dennou Club - 2000.3 Vol. 142 (Japan).7z / Gekkan Dennou Club - 2000.3 Vol. 142 (Japan) (Track 1).bin / tools / s_tool / subg.c < prev    next >
Text File  |  1997-10-25  |  26KB  |  1,095 lines
  1. #include    "JX250.H"
  2. #include    <sys\iocs.h>
  3. #include    <sys\dos.h>
  4. #include    <sys\scsi.h>
  5. #include    <stdio.h>
  6. #include    <stdlib.h>
  7. #include    <math.h>
  8. #include    <_tnb.c>
  9.  
  10.  
  11. extern    UNchar    RG_[256],GG_[256],BG_[256];
  12. extern    UNshort    RG0[256],GG0[256],BG0[256];
  13. extern    UNshort    RG1[256],GG1[256],BG1[256];
  14. extern    int    DataMd;
  15. extern    int    DataC;
  16. extern    int    PreDataMd;
  17. extern    int    PreDataBi;
  18. extern    UNchar    msp[17];
  19.  
  20. static short DefocusT[3][3]={
  21.         1,2,1,
  22.         2,5,2,
  23.         1,2,1
  24. };
  25.  
  26. static    short    mca[]={1,2,3,-1};
  27. static    short    mca2[]={6,6,7,7,8,8,-1};
  28. void    GG2PSET_64_S(),GG4PSET_64_S(),GG8PSET_64_S();
  29. static    void (*_GG_PSETS[8])()={(void*)0,&GG2PSET_64_S,&GG4PSET_64_S,&GG8PSET_64_S};
  30.  
  31. #define    Mul(x,y)    MULU(x,y)
  32. //#define    Mul(x,y)    (x*y)
  33.  
  34. /**************************************************
  35.         スキャン画像表示
  36. **************************************************/
  37. void    ScanGraphView(ofx,ofy,mm)
  38. int    ofx,ofy,mm;
  39. {
  40. int    i,v,l,bi,e,bisx,bisy,vst;
  41. int    x,y,xx,z,ye,dataxz;
  42. int    ssp;
  43. UNchar    *M,*N;
  44. UNshort    *V,*W;
  45. int    stz,scrx,scry;
  46. int    _scrx,_scry;
  47. void    (*GGPSETS)();
  48. M=ScanData;
  49. x=ScanDataX-ofx;
  50. y=ScanDataY-ofy;
  51. if ( mm==0 ){
  52.     // 記録モード用
  53.     stz=16;
  54.     scrx=256;
  55.     scry=480;
  56.     ssp=_iocs_b_super(0);
  57.     if ( M==0 ){
  58.         GGSP16_64_S(TADDS(3,0),0x02);
  59.         GGSP16_64_S(TADDS(4,0),0x02);
  60.         GGSP16_64_S(TADDS(5,0),0x02);
  61.     } elif ( DataC==0 ){
  62.         GGSP16_64_S(TADDS(3,0),0xC2);
  63.         GGSP16_64_S(TADDS(4,0),0xC3);
  64.         GGSP16_64_S(TADDS(5,0),0xC4);
  65.     } elif ( DataMd==5 ){                // フルカラー
  66.         GGSP16_64_S(TADDS(3,0),0xC0);
  67.         GGSP16_64_S(TADDS(4,0),0xC1);
  68.         GGSP16_64_S(TADDS(5,0),0xC4);
  69.     } else {
  70.         GGSP16_64_S(TADDS(3,0),0xC0);
  71.         GGSP16_64_S(TADDS(4,0),0xC5);
  72.         GGSP16_64_S(TADDS(5,0),0xC6);
  73.     }
  74.     if ( ssp>0 )
  75.         _iocs_b_super(ssp);
  76. } else {
  77.     // 全画面
  78.     stz=0;
  79.     scrx=512;
  80.     scry=512;
  81. }
  82. if ( M==0 ){
  83.     struct _fillptr PP;
  84.     PP.x1=stz;
  85.     PP.y1=stz;
  86.     PP.x2=stz+scrx-1;
  87.     PP.y2=stz+scry-1;
  88.     PP.color=0;
  89.     _iocs_fill(&PP);
  90.     return;
  91. }
  92. _scrx=scrx+stz;
  93. _scry=scry+stz;
  94. if ( DataC!=0 ){
  95.     if ( DataMd==5 )                // フルカラー
  96.         z=3;
  97.     else    z=1;
  98. }
  99. dataxz=DataX*z;
  100. ssp=_iocs_b_super(0);
  101. if ( RecVwBai>0 ){
  102.             // 1;x2  2;x4 3;x8
  103.     bi=1<<RecVwBai;
  104.     bisx=scrx/bi;
  105.     bisy=scry/bi;
  106.     vst=bi*2;
  107.     GGPSETS=_GG_PSETS[RecVwBai];
  108.     ye=bisy;
  109.     if ( ye>y )
  110.         ye=y;
  111.     if ( DataC!=0 ){
  112.         //===================== 24bit カラー記憶
  113.         for(l=0;l<ye;l++){
  114.             //    printf("    複走査 = %d(%d)\r",l,y);
  115.             N=&M[ Mul(ofx,z)+Mul(l+ofy,dataxz) ];
  116.             xx=x;
  117.             if ( xx>bisx )
  118.                 xx=bisx;
  119.             v=VADDS(0,stz,Mul(l,bi)+stz);
  120.             if ( DataMd==5 ){                // フルカラー
  121.                 for(i=0;i<xx;i++,N+=3,v+=vst)
  122.                     GGPSETS(v,RGB(N[0]/8,N[1]/8,N[2]/8));
  123.                 for(;i<bisx;i++,v+=vst)
  124.                     GGPSETS(v,0);
  125.             } elif ( DataMd==2 ){            // グレイスケール
  126.                 for(i=0;i<xx;i++,N++,v+=vst){
  127.                     e=N[0]/8;
  128.                     GGPSETS(v,RGB(e,e,e));
  129.                 }
  130.                 for(;i<bisx;i++,v+=vst)
  131.                     GGPSETS(v,0);
  132.             }
  133.         }
  134.     } else {
  135.         //===================== 64k カラー記憶
  136.         for(l=0;l<ye;l++){
  137.         //    printf("    複走査 = %d(%d)\r",l,y);
  138.             W=&M[ (ofx+Mul(l+ofy,DataX)) *2 ];
  139.             xx=x;
  140.             if ( xx>bisx )
  141.                 xx=bisx;
  142.             v=VADDS(0,stz,Mul(l,bi)+stz);
  143.             for(i=0;i<xx;i++,v+=vst)
  144.                 GGPSETS(v,*W++);
  145.             for(;i<bisx;i++,v+=vst)
  146.                 GGPSETS(v,0);
  147.         }
  148.     }
  149.     //-- 空白
  150.     for(;;l++){
  151.         if ( (l*bi)+stz>=_scry )
  152.             break;
  153.         v=VADDS(0,stz,Mul(l,bi)+stz);
  154.         for(i=0;i<bisx;i++,v+=vst)
  155.             GGPSETS(v,0);
  156.     }
  157.     if ( mm==0 ){
  158.         ScroolBarX(ScanDataX*bi,256,ofx*bi);
  159.         ScroolBarY(ScanDataY*bi,480,ofy*bi);
  160.     }
  161. } else {
  162.             //0;1 -1;/2  -2;/4  -3;/8
  163.     bi=1 << (-RecVwBai);
  164.     x/=bi;
  165.     y/=bi;
  166.     ye=scry;
  167.     if ( ye>y )
  168.         ye=y;
  169.     if ( DataC!=0 ){
  170.         //===================== 24bit カラー記憶
  171.         for(l=0;l<ye;l++){
  172.             //    printf("    複走査 = %d(%d)\r",l,y);
  173.             N=&M[ Mul(ofx,z)+Mul(Mul(l,bi)+ofy,dataxz) ];
  174.             xx=x;
  175.             if ( xx>scrx )
  176.                 xx=scrx;
  177.             V=VADDS(0,stz,l+stz);
  178.             if ( DataMd==5 ){                // フルカラー
  179.                 for(i=0;i<xx;i++){
  180.                     *V++=RGB(N[0]/8,N[1]/8,N[2]/8);
  181.                     N+=3*bi;
  182.                 }
  183.             } elif ( DataMd==2 ){            // グレイスケール
  184.                 for(i=0;i<xx;i++){
  185.                     e=N[0]/8;
  186.                     *V++=RGB(e,e,e);
  187.                     N+=bi;
  188.                 }
  189.             }
  190.             for(;i<scrx;i++)
  191.                 *V++=0;
  192.         }
  193.     } else {
  194.         //===================== 64k カラー記憶
  195.         for(l=0;l<ye;l++){
  196.             //    printf("    複走査 = %d(%d)\r",l,y);
  197.             W=&M[ (ofx+Mul(Mul(l,bi)+ofy,DataX)) *2 ];
  198.             xx=x;
  199.             if ( xx>scrx )
  200.                 xx=scrx;
  201.             V=VADDS(0,stz,l+stz);
  202.             for(i=0;i<xx;i++,W+=bi)
  203.                 *V++=*W;
  204.             for(;i<scrx;i++)
  205.                 *V++=0;
  206.         }
  207.     }
  208.     for(;;l++){
  209.         if ( l+stz>=_scry )
  210.             break;
  211.         V=VADDS(0,stz,l+stz);
  212.         for(i=0;i<scrx;i++)
  213.             *V++=0;
  214.     }
  215.     if ( mm==0 ){
  216.         ScroolBarX(ScanDataX/bi,256,ofx/bi);
  217.         ScroolBarY(ScanDataY/bi,480,ofy/bi);
  218.     }
  219. }
  220. if ( ssp>0 )
  221.     _iocs_b_super(ssp);
  222. }
  223. /*----------------------------------------------------------------------*/
  224. /**************************************************
  225.         スキャン画像表示
  226.             MONO
  227.             グレイスケール表示
  228.         mm=1;Gray
  229.            2;Mono
  230.            3;DeFocus
  231. **************************************************/
  232. void    ScanGraphView_gm(ofx,ofy,mm)
  233. int    ofx,ofy,mm;
  234. {
  235. int    i,v,l,bi,bisx,bisy,vst,ofyl;
  236. int    x,y,xx,z,x_,ye,om,dataxz;
  237. int    ssp;
  238. UNchar    *M,*N;
  239. UNshort    *V,*W;
  240. int    stz,scrx,scry;
  241. int    _scrx,_scry;
  242. void    (*GGPSETS)();
  243. M=ScanData;
  244. x=ScanDataX-ofx;
  245. y=ScanDataY-ofy;
  246. // 全画面
  247. stz=0;
  248. scrx=512;
  249. scry=512;
  250. if ( M==0 ){
  251.     struct _fillptr PP;
  252.     PP.x1=stz;
  253.     PP.y1=stz;
  254.     PP.x2=stz+scrx-1;
  255.     PP.y2=stz+scry-1;
  256.     PP.color=0;
  257.     _iocs_fill(&PP);
  258.     return;
  259. }
  260. _iocs_ms_sel2(mca);
  261. om=_iocs_ms_curgt();
  262. _scrx=scrx+stz;
  263. _scry=scry+stz;
  264. if ( DataC!=0 ){
  265.     if ( DataMd==5 )                // フルカラー
  266.         z=3;
  267.     else    z=1;
  268. }
  269. DefocusT[1][1]=DefocusPoint*4+8;
  270. dataxz=DataX*z;
  271. ssp=_iocs_b_super(0);
  272. if ( RecVwBai>0 ){
  273.             // 1;x2  2;x4 3;x8
  274.     bi=1<<RecVwBai;
  275.     bisx=scrx/bi;
  276.     bisy=scry/bi;
  277.     vst=bi*2;
  278.     GGPSETS=_GG_PSETS[RecVwBai];
  279.     ye=bisy;
  280.     if ( ye>y )
  281.         ye=y;
  282.     if ( DataC!=0 ){
  283.         //===================================== 24bit カラー記憶
  284.         for(l=0;l<ye;l++){
  285.             //    printf("    複走査 = %d(%d)\r",l,y);
  286.             ofyl=l+ofy;
  287.             N=&M[ Mul(ofx,z)+Mul(ofyl,dataxz) ];
  288.             xx=x;
  289.             if ( xx>bisx )
  290.                 xx=bisx;
  291.             v=VADDS(0,stz,Mul(l,bi)+stz);
  292.             if ( mm==1 ){
  293.                 //===== グレイスケール化 
  294.                 if ( DataMd==5 ){                // フルカラー
  295.                     for(i=0;i<xx;i++,N+=3,v+=vst)
  296.                         GGPSETS(v,GrayColorDisp24_(N[0],N[1],N[2]));
  297.                 } elif ( DataMd==2 ){                // グレイスケール
  298.                     ;        // もともとなので必要なし
  299.                 }
  300.             } elif ( mm==2 ){
  301.                 //==== 二値化
  302.                 if ( DataMd==5 ){                // フルカラー
  303.                     for(i=0;i<xx;i++,N+=3,v+=vst)
  304.                         GGPSETS(v,MonoColorDisp24_(N[1]));
  305.                 } elif ( DataMd==2 ){                // グレイスケール
  306.                     for(i=0;i<xx;i++,N++,v+=vst)
  307.                         GGPSETS(v,MonoColorDisp24_(N[0]));
  308.                 }
  309.             } elif ( mm==3 ){
  310.                 //===== 平滑化 
  311.                 if ( DataMd==5 ){                // フルカラー
  312.                     for(i=0,x_=ofx;i<xx;i++,v+=vst,x_++)
  313.                         GGPSETS(v,DefocusDisp24_(M,x_,ofyl) );
  314.                 } elif ( DataMd==2 ){                // グレイスケール
  315.                     for(i=0,x_=ofx;i<xx;i++,v+=vst,x_++)
  316.                         GGPSETS(v,DefocusDisp24G_(M,x_,ofyl) );
  317.                 }
  318.             } elif ( mm==4 ){
  319.                 //===== ﾒﾃﾞｨｱﾝ化 
  320.                 if ( DataMd==5 ){                // フルカラー
  321.                     for(i=0,x_=ofx;i<xx;i++,v+=vst,x_++)
  322.                         GGPSETS(v,MedianDisp24_(M,x_,ofyl) );
  323.                 } elif ( DataMd==2 ){                // グレイスケール
  324.                     for(i=0,x_=ofx;i<xx;i++,v+=vst,x_++)
  325.                         GGPSETS(v,MedianDisp24G_(M,x_,ofyl) );
  326.                 }
  327.             } elif ( mm==5 ){
  328.                 //===== 鮮鋭化 
  329.                 if ( DataMd==5 ){                // フルカラー
  330.                     for(i=0,x_=ofx;i<xx;i++,v+=vst,x_++)
  331.                         GGPSETS(v,SharpDisp24_(M,x_,ofyl) );
  332.                 } elif ( DataMd==2 ){                // グレイスケール
  333.                     for(i=0,x_=ofx;i<xx;i++,v+=vst,x_++)
  334.                         GGPSETS(v,SharpDisp24G_(M,x_,ofyl) );
  335.                 }
  336.             }
  337.             if ( MS_RSW() )
  338.                 break;
  339.             _iocs_ms_curst( 8,Mul(l,bi) );
  340.         }
  341.     } else {
  342.         //==================================== 64k カラー記憶
  343.         for(l=0;l<ye;l++){
  344.         //    printf("    複走査 = %d(%d)\r",l,y);
  345.             ofyl=ofy+l;
  346.             W=&M[ (ofx+Mul(ofyl,DataX)) *2 ];
  347.             xx=x;
  348.             if ( xx>bisx )
  349.                 xx=bisx;
  350.             v=VADDS(0,stz,(l*bi)+stz);
  351.             if ( mm==1 ){
  352.                 //==== グレイスケール化
  353.                 for(i=0;i<xx;i++,v+=vst)
  354.                     GGPSETS(v,GrayColorDisp64(*W++));
  355.             } elif ( mm==2 ){
  356.                 //==== 二値化
  357.                 for(i=0;i<xx;i++,v+=vst)
  358.                     GGPSETS(v,MonoColorDisp64(*W++));
  359.             } elif ( mm==3 ){
  360.                 //==== 平滑化
  361.                 for(i=0,x_=ofx;i<xx;i++,v+=vst,x_++)
  362.                     GGPSETS(v,DefocusDisp64(M,x_,ofyl) );
  363.             } elif ( mm==4 ){
  364.                 //==== ﾒﾃﾞｨｱﾝ化
  365.                 for(i=0,x_=ofx;i<xx;i++,v+=vst,x_++)
  366.                     GGPSETS(v,MedianDisp64(M,x_,ofyl) );
  367.             } elif ( mm==5 ){
  368.                 //==== 鮮鋭化
  369.                 for(i=0,x_=ofx;i<xx;i++,v+=vst,x_++)
  370.                     GGPSETS(v,SharpDisp64(M,x_,ofyl) );
  371.             }
  372.             if ( MS_RSW() )
  373.                 break;
  374.             _iocs_ms_curst( 8,Mul(l,bi) );
  375.         }
  376.     }
  377. } else {
  378.             //0;1 -1;/2  -2;/4  -3;/8
  379.     bi=1 << (-RecVwBai);
  380.     x/=bi;
  381.     y/=bi;
  382.     ye=scry;
  383.     if ( ye>y )
  384.         ye=y;
  385.     if ( DataC!=0 ){
  386.         //============================= 24bit カラー記憶
  387.         for(l=0;l<ye;l++){
  388.             //    printf("    複走査 = %d(%d)\r",l,y);
  389.             ofyl=ofy+l*bi;
  390.             N=&M[ Mul(ofx,z)+Mul(ofyl,dataxz) ];
  391.             xx=x;
  392.             if ( xx>scrx )
  393.                 xx=scrx;
  394.             V=VADDS(0,stz,l+stz);
  395.             if ( mm==1 ){
  396.                 //==== グレイスケール化
  397.                 if ( DataMd==5 ){                // フルカラー
  398.                     for(i=0;i<xx;i++,N+=3*bi)
  399.                         *V++=GrayColorDisp24_(N[0],N[1],N[2]);
  400.                 } elif ( DataMd==2 ){                // グレイスケール
  401.                     ;
  402.                 }
  403.             } elif ( mm==2 ){
  404.                 //==== 二値化
  405.                 if ( DataMd==5 ){                // フルカラー
  406.                     for(i=0;i<xx;i++,N+=3*bi)
  407.                         *V++=MonoColorDisp24_(N[1]);
  408.                 } elif ( DataMd==2 ){                // グレイスケール
  409.                     for(i=0;i<xx;i++,N+=bi)
  410.                         *V++=MonoColorDisp24_(N[0]);
  411.                 }
  412.             } elif ( mm==3 ){
  413.                 //==== 平滑化
  414.                 if ( DataMd==5 ){                // フルカラー
  415.                     for(i=0,x_=ofx;i<xx;i++,x_+=bi)
  416.                         *V++=DefocusDisp24_(M,x_,ofyl);
  417.                 } elif ( DataMd==2 ){                // グレイスケール
  418.                     for(i=0,x_=ofx;i<xx;i++,x_+=bi)
  419.                         *V++=DefocusDisp24G_(M,x_,ofyl);
  420.                 }
  421.             } elif ( mm==4 ){
  422.                 //==== ﾒﾃﾞｨｱﾝ化
  423.                 if ( DataMd==5 ){                // フルカラー
  424.                     for(i=0,x_=ofx;i<xx;i++,x_+=bi)
  425.                         *V++=MedianDisp24_(M,x_,ofyl);
  426.                 } elif ( DataMd==2 ){                // グレイスケール
  427.                     for(i=0,x_=ofx;i<xx;i++,x_+=bi)
  428.                         *V++=MedianDisp24G_(M,x_,ofyl);
  429.                 }
  430.             } elif ( mm==5 ){
  431.                 //==== 鮮鋭化
  432.                 if ( DataMd==5 ){                // フルカラー
  433.                     for(i=0,x_=ofx;i<xx;i++,x_+=bi)
  434.                         *V++=SharpDisp24_(M,x_,ofyl);
  435.                 } elif ( DataMd==2 ){                // グレイスケール
  436.                     for(i=0,x_=ofx;i<xx;i++,x_+=bi)
  437.                         *V++=SharpDisp24G_(M,x_,ofyl);
  438.                 }
  439.             }
  440.             if ( MS_RSW() )
  441.                 break;
  442.             _iocs_ms_curst( 8,l);
  443.         }
  444.     } else {
  445.         //================================ 64k カラー記憶
  446.         for(l=0;l<ye;l++){
  447.             //    printf("    複走査 = %d(%d)\r",l,y);
  448.             ofyl=ofy+l*bi;
  449.             W=&M[ (ofx+Mul(ofyl,DataX)) *2 ];
  450.             xx=x;
  451.             if ( xx>scrx )
  452.                 xx=scrx;
  453.             V=VADDS(0,stz,l+stz);
  454.             if ( mm==1 ){
  455.                 for(i=0;i<xx;i++,W+=bi)
  456.                     *V++=GrayColorDisp64(*W);
  457.             } elif ( mm==2 ){
  458.                 //==== ２値化
  459.                 for(i=0;i<xx;i++,W+=bi)
  460.                     *V++=MonoColorDisp64(*W);
  461.             } elif ( mm==3 ){
  462.                 //==== 平滑化
  463.                 for(i=0,x_=ofx;i<xx;i++,x_+=bi)
  464.                     *V++=DefocusDisp64(M,x_,ofyl);
  465.             } elif ( mm==4 ){
  466.                 //==== ﾒﾃﾞｨｱﾝ化
  467.                 for(i=0,x_=ofx;i<xx;i++,x_+=bi)
  468.                     *V++=MedianDisp64(M,x_,ofyl);
  469.             } elif ( mm==5 ){
  470.                 //==== 鮮鋭化
  471.                 for(i=0,x_=ofx;i<xx;i++,x_+=bi)
  472.                     *V++=SharpDisp64(M,x_,ofyl);
  473.             }
  474.             if ( MS_RSW() )
  475.                 break;
  476.             _iocs_ms_curst( 8,l);
  477.         }
  478.     }
  479. }
  480. if ( ssp>0 )
  481.     _iocs_b_super(ssp);
  482. MsPat(1);
  483. _iocs_ms_curst( om/0x10000,om&0xFFFF );
  484. }
  485. /*----------------------------------------------------------------------*/
  486. /*                各処理                    */
  487. /*----------------------------------------------------------------------*/
  488. /**************************
  489. ２値化 24bit カラー
  490. ***************************/
  491. inline static int MonoColorDisp24(g)
  492. int    g;
  493. {
  494. int    i;
  495. i=(g<MonoPoint)?0:255;
  496. return( i );
  497. }
  498. /*+++DATA用+++*/
  499. inline static int MonoColorDisp24_(g)
  500. int    g;
  501. {
  502. int    i;
  503. i=MonoColorDisp24(g);
  504. i=(g<MonoPoint)?0:65535;
  505. return( i );
  506. }
  507. /**************************
  508. ２値化 64kカラー
  509. ***************************/
  510. inline static int MonoColorDisp64(c)
  511. int    c;
  512. {
  513. int    i;
  514. i=((GG(c)*8)<MonoPoint)?0:65535;
  515. return(i);
  516. }
  517. /*----------------------------------------*/
  518. /**************************
  519. グレイスケール化 24bitカラー
  520. ***************************/
  521. inline static int GrayColorDisp24(r,g,b)
  522. int    r,g,b;
  523. {
  524. int    i;
  525. //i=DIVU( MULU(g,GrayPoint)+MULU(b,31-GrayPoint),31);
  526. i=MULU(g,GrayPoint)+MULU(b,31-GrayPoint);
  527. i=DIVU( i,31 );
  528. i=(i*3+r)/4;
  529. return(i);
  530. }
  531. /*+++DATA用+++*/
  532. inline static int GrayColorDisp24_(r,g,b)
  533. int    r,g,b;
  534. {
  535. int    i;
  536. i=GrayColorDisp24(r,g,b);
  537. i/=8;
  538. return(RGB(i,i,i));
  539. }
  540. /**************************
  541. グレイスケール化 64kカラー
  542. ***************************/
  543. inline static int GrayColorDisp64(c)
  544. int    c;
  545. {
  546. int    i,r,g,b;
  547. r=RR(c);
  548. g=GG(c);
  549. b=BB(c);
  550. i=GrayColorDisp24(r,g,b);
  551. return( RGB(i,i,i) );
  552. }
  553. /*----------------------------------------*/
  554. /**************************
  555. 平滑化 24bitカラー
  556. ***************************/
  557. inline static int DefocusDisp24(bb,sx,sy)
  558. UNchar    *bb;            // DataX*3 幅のバッファ
  559. int    sx,sy;            // b[x+y*DataX] に元データ
  560. {
  561. int    i,x,y,z;
  562. int    r,g,b;
  563. z=0; r=0; g=0; b=0;
  564. for(y=sy-1;y<=sy+1;y++){
  565.     if ( y<0 || y>=ScanDataY )
  566.         continue;
  567.     for(x=sx-1;x<=sx+1;x++){
  568.         if ( x<0 || x>=ScanDataX )
  569.             continue;
  570.         i=DefocusT[y-sy+1][x-sx+1];
  571.         z+=i;
  572.         r+=MULU( bb[(x+MULU(y,DataX))*3+0],i );
  573.         g+=MULU( bb[(x+MULU(y,DataX))*3+1],i );
  574.         b+=MULU( bb[(x+MULU(y,DataX))*3+2],i );
  575.     }
  576. }
  577. if ( z==0 )
  578.     return(0);
  579. r=DIVU(r,z);
  580. g=DIVU(g,z);
  581. b=DIVU(b,z);
  582. return( r*0x10000+g*0x100+b );
  583. }
  584. /*+++++++++*/
  585. inline static int DefocusDisp24_(bb,sx,sy)
  586. UNchar    *bb;            // DataX*3 幅のバッファ
  587. int    sx,sy;            // b[x+y*DataX] に元データ
  588. {
  589. int    c;
  590. c=DefocusDisp24(bb,sx,sy);
  591. return( RGB( ((c/0x10000)&0xFF)/8,((c/0x100)&0xFF)/8,(c&0xFF)/8) );
  592. }
  593. /**************************
  594. 平滑化 24bitグレイスケール
  595. ***************************/
  596. inline static int DefocusDisp24G(bb,sx,sy)
  597. UNchar    *bb;            // DataX 幅のバッファ
  598. int    sx,sy;            // b[x+y*DataX] に元データ
  599. {
  600. int    i,c,x,y,z;
  601. int    r;
  602. z=0; r=0;
  603. for(y=sy-1;y<=sy+1;y++){
  604.     if ( y<0 || y>=ScanDataY )
  605.         continue;
  606.     for(x=sx-1;x<=sx+1;x++){
  607.         if ( x<0 || x>=ScanDataX )
  608.             continue;
  609.         i=DefocusT[y-sy+1][x-sx+1];
  610.         z+=i;
  611.         r+=MULU( bb[x+MULU(y,DataX)],i );
  612.     }
  613. }
  614. if ( z==0 )
  615.     return(0);
  616. r=DIVU(r,z);
  617. return( r );
  618. }
  619. /*+++++++++*/
  620. inline static int DefocusDisp24G_(bb,sx,sy)
  621. UNchar    *bb;            // DataX*3 幅のバッファ
  622. int    sx,sy;            // b[x+y*DataX] に元データ
  623. {
  624. int    c;
  625. c=DefocusDisp24G(bb,sx,sy);
  626. c=(c&0xFF)/8;
  627. return( RGB(c,c,c) );
  628. }
  629. /**************************
  630. 平滑化 64kカラー
  631. ***************************/
  632. inline static int DefocusDisp64(bb,sx,sy)
  633. UNshort    *bb;            // DataX 幅のバッファ
  634. int    sx,sy;            // b[x+y*DataX] に元データ
  635. {
  636. int    i,c,x,y,z;
  637. int    r,g,b;
  638. z=0; r=0; g=0; b=0;
  639. for(y=sy-1;y<=sy+1;y++){
  640.     if ( y<0 || y>=ScanDataY )
  641.         continue;
  642.     for(x=sx-1;x<=sx+1;x++){
  643.         if ( x<0 || x>=ScanDataX )
  644.             continue;
  645.         i=DefocusT[y-sy+1][x-sx+1];
  646.         z+=i;
  647.         c=bb[x+MULU(y,DataX)];
  648.         r+=MULU( RR(c),i );
  649.         g+=MULU( GG(c),i );
  650.         b+=MULU( BB(c),i );
  651.     }
  652. }
  653. if ( z==0 )
  654.     return(0);
  655. r=DIVU(r,z);
  656. g=DIVU(g,z);
  657. b=DIVU(b,z);
  658. return( RGB(r,g,b) );
  659. }
  660. /*----------------------------------------*/
  661. /**************************
  662. ﾒﾃﾞｨｱﾝ化 24bitカラー
  663. ***************************/
  664. inline static int MedianDisp24(bb,sx,sy)
  665. UNchar    *bb;            // DataX*3 幅のバッファ
  666. int    sx,sy;            // b[x+y*DataX] に元データ
  667. {
  668. int    r,g,b;
  669. if ( sx<1 || sx>=ScanDataX-1 || sy<1 || sy>=ScanDataY-1 ){
  670.     r=bb[(sx+MULU(sy,DataX))*3+0];
  671.     g=bb[(sx+MULU(sy,DataX))*3+1];
  672.     b=bb[(sx+MULU(sy,DataX))*3+2];
  673. } else {
  674.     r=sort5intM(
  675.         bb[((sx  )+MULU((sy  ),DataX))*3+0],
  676.         bb[((sx+1)+MULU((sy  ),DataX))*3+0],
  677.         bb[((sx  )+MULU((sy-1),DataX))*3+0],
  678.         bb[((sx-1)+MULU((sy  ),DataX))*3+0],
  679.         bb[((sx  )+MULU((sy+1),DataX))*3+0]
  680.     );
  681.     g=sort5intM(
  682.         bb[((sx  )+MULU((sy  ),DataX))*3+1],
  683.         bb[((sx+1)+MULU((sy  ),DataX))*3+1],
  684.         bb[((sx  )+MULU((sy-1),DataX))*3+1],
  685.         bb[((sx-1)+MULU((sy  ),DataX))*3+1],
  686.         bb[((sx  )+MULU((sy+1),DataX))*3+1]
  687.     );
  688.     b=sort5intM(
  689.         bb[((sx  )+MULU((sy  ),DataX))*3+2],
  690.         bb[((sx+1)+MULU((sy  ),DataX))*3+2],
  691.         bb[((sx  )+MULU((sy-1),DataX))*3+2],
  692.         bb[((sx-1)+MULU((sy  ),DataX))*3+2],
  693.         bb[((sx  )+MULU((sy+1),DataX))*3+2]
  694.     );
  695. }
  696. return( r*0x10000+g*0x100+b );
  697. }
  698. /*+++++++++*/
  699. inline static int MedianDisp24_(bb,sx,sy)
  700. UNchar    *bb;            // DataX*3 幅のバッファ
  701. int    sx,sy;            // b[x+y*DataX] に元データ
  702. {
  703. int    c;
  704. c=MedianDisp24(bb,sx,sy);
  705. return( RGB( ((c/0x10000)&0xFF)/8,((c/0x100)&0xFF)/8,(c&0xFF)/8) );
  706. }
  707. /**************************
  708. ﾒﾃﾞｨｱﾝ化 24bitグレイスケール
  709. ***************************/
  710. inline static int MedianDisp24G(bb,sx,sy)
  711. UNchar    *bb;            // DataX*3 幅のバッファ
  712. int    sx,sy;            // b[x+y*DataX] に元データ
  713. {
  714. int    r;
  715. if ( sx<1 || sx>=ScanDataX-1 || sy<1 || sy>=ScanDataY-1 ){
  716.     r=bb[sx+MULU(sy,DataX)];
  717. } else {
  718.     r=sort5intM(
  719.         bb[(sx  )+MULU((sy  ),DataX)],
  720.         bb[(sx+1)+MULU((sy  ),DataX)],
  721.         bb[(sx  )+MULU((sy-1),DataX)],
  722.         bb[(sx-1)+MULU((sy  ),DataX)],
  723.         bb[(sx  )+MULU((sy+1),DataX)]
  724.     );
  725. }
  726. return( r );
  727. }
  728. /*+++++++++*/
  729. inline static int MedianDisp24G_(bb,sx,sy)
  730. UNchar    *bb;            // DataX*3 幅のバッファ
  731. int    sx,sy;            // b[x+y*DataX] に元データ
  732. {
  733. int    c;
  734. c=MedianDisp24G(bb,sx,sy);
  735. c=(c&0xFF)/8;
  736. return( RGB(c,c,c) );
  737. }
  738. /**************************
  739. ﾒﾃﾞｨｱﾝ化 64kカラー
  740. ***************************/
  741. inline static int MedianDisp64(bb,sx,sy)
  742. UNshort    *bb;            // DataX 幅のバッファ
  743. int    sx,sy;            // b[x+y*DataX] に元データ
  744. {
  745. int    r,g,b;
  746. if ( sx<1 || sx>=ScanDataX-1 || sy<1 || sy>=ScanDataY-1 ){
  747.     return( bb[sx+MULU(sy,DataX)] );
  748. }
  749. r=sort5intM(
  750.     RR( bb[(sx  )+MULU((sy  ),DataX)] ),
  751.     RR( bb[(sx+1)+MULU((sy  ),DataX)] ),
  752.     RR( bb[(sx  )+MULU((sy-1),DataX)] ),
  753.     RR( bb[(sx-1)+MULU((sy  ),DataX)] ),
  754.     RR( bb[(sx  )+MULU((sy+1),DataX)] )
  755. );
  756. g=sort5intM(
  757.     GG( bb[(sx  )+MULU((sy  ),DataX)] ),
  758.     GG( bb[(sx+1)+MULU((sy  ),DataX)] ),
  759.     GG( bb[(sx  )+MULU((sy-1),DataX)] ),
  760.     GG( bb[(sx-1)+MULU((sy  ),DataX)] ),
  761.     GG( bb[(sx  )+MULU((sy+1),DataX)] )
  762. );
  763. b=sort5intM(
  764.     BB( bb[(sx  )+MULU((sy  ),DataX)] ),
  765.     BB( bb[(sx+1)+MULU((sy  ),DataX)] ),
  766.     BB( bb[(sx  )+MULU((sy-1),DataX)] ),
  767.     BB( bb[(sx-1)+MULU((sy  ),DataX)] ),
  768.     BB( bb[(sx  )+MULU((sy+1),DataX)] )
  769. );
  770. return( RGB(r,g,b) );
  771. }
  772. /*----------------------------------------*/
  773. /**************************
  774. 鮮鋭化 24bitカラー
  775. ***************************/
  776. inline static int SharpDisp24(bb,sx,sy)
  777. UNchar    *bb;            // DataX*3 幅のバッファ
  778. int    sx,sy;            // b[x+y*DataX] に元データ
  779. {
  780. int    i,r,g,b;
  781. static short ssx[4]={-1,0,1,0};
  782. static short ssy[4]={0,-1,0,1};
  783. if ( sx<1 || sx>=ScanDataX-1 || sy<1 || sy>=ScanDataY-1 ){
  784.     r=bb[(sx+MULU(sy,DataX))*3+0];
  785.     g=bb[(sx+MULU(sy,DataX))*3+1];
  786.     b=bb[(sx+MULU(sy,DataX))*3+2];
  787. } else {
  788.     r=bb[(sx+MULU(sy,DataX))*3+0]*8;
  789.     g=bb[(sx+MULU(sy,DataX))*3+1]*8;
  790.     b=bb[(sx+MULU(sy,DataX))*3+2]*8;
  791.     for(i=0;i<4;i++){
  792.         r-=bb[((sx+ssx[i])+MULU((sy+ssy[i]),DataX))*3+0];
  793.         g-=bb[((sx+ssx[i])+MULU((sy+ssy[i]),DataX))*3+1];
  794.         b-=bb[((sx+ssx[i])+MULU((sy+ssy[i]),DataX))*3+2];
  795.     }
  796.     r/=4; g/=4; b/=4;
  797.     if ( r<0 ) r=0;
  798.     if ( g<0 ) g=0;
  799.     if ( b<0 ) b=0;
  800.     if ( r>255 ) r=255;
  801.     if ( g>255 ) g=255;
  802.     if ( b>255 ) b=255;
  803. }
  804. return( r*0x10000+g*0x100+b );
  805. }
  806. /*+++++++++*/
  807. inline static int SharpDisp24_(bb,sx,sy)
  808. UNchar    *bb;            // DataX*3 幅のバッファ
  809. int    sx,sy;            // b[x+y*DataX] に元データ
  810. {
  811. int    c;
  812. c=SharpDisp24(bb,sx,sy);
  813. return( RGB( ((c/0x10000)&0xFF)/8,((c/0x100)&0xFF)/8,(c&0xFF)/8) );
  814. }
  815. /**************************
  816. 鮮鋭化 24bitグレイスケール
  817. ***************************/
  818. inline static int SharpDisp24G(bb,sx,sy)
  819. UNchar    *bb;            // DataX*3 幅のバッファ
  820. int    sx,sy;            // b[x+y*DataX] に元データ
  821. {
  822. int    i,r;
  823. static short ssx[4]={-1,0,1,0};
  824. static short ssy[4]={0,-1,0,1};
  825. if ( sx<1 || sx>=ScanDataX-1 || sy<1 || sy>=ScanDataY-1 ){
  826.     r=bb[sx+MULU(sy,DataX)];
  827. } else {
  828.     r=bb[sx+MULU(sy,DataX)]*8;
  829.     for(i=0;i<4;i++){
  830.         r-=bb[(sx+ssx[i])+MULU((sy+ssy[i]),DataX)];
  831.     }
  832.     r/=4;
  833.     if ( r<0 ) r=0;
  834.     if ( r>255 ) r=255;
  835. }
  836. return( r );
  837. }
  838. /*+++++++++*/
  839. inline static int SharpDisp24G_(bb,sx,sy)
  840. UNchar    *bb;            // DataX*3 幅のバッファ
  841. int    sx,sy;            // b[x+y*DataX] に元データ
  842. {
  843. int    c;
  844. c=SharpDisp24G(bb,sx,sy);
  845. c=(c&0xFF)/8;
  846. return( RGB(c,c,c) );
  847. }
  848. /**************************
  849. 鮮鋭化 64kカラー
  850. ***************************/
  851. inline static int SharpDisp64(bb,sx,sy)
  852. UNshort    *bb;            // DataX 幅のバッファ
  853. int    sx,sy;            // b[x+y*DataX] に元データ
  854. {
  855. int    i,c;
  856. int    r,g,b;
  857. static short ssx[4]={-1,0,1,0};
  858. static short ssy[4]={0,-1,0,1};
  859. if ( sx<1 || sx>=ScanDataX-1 || sy<1 || sy>=ScanDataY-1 ){
  860.     return( bb[sx+MULU(sy,DataX)] );
  861. }
  862. c=bb[sx+MULU(sy,DataX)];
  863. r=RR(c)*8;
  864. g=GG(c)*8;
  865. b=BB(c)*8;
  866. for(i=0;i<4;i++){
  867.     c=bb[(sx+ssx[i])+MULU((sy+ssy[i]),DataX)];
  868.     r-=RR(c);
  869.     g-=GG(c);
  870.     b-=BB(c);
  871. }
  872. r/=4; g/=4; b/=4;
  873. if ( r<0 ) r=0;
  874. if ( g<0 ) g=0;
  875. if ( b<0 ) b=0;
  876. if ( r>31 ) r=31;
  877. if ( g>31 ) g=31;
  878. if ( b>31 ) b=31;
  879. return( RGB(r,g,b) );
  880. }
  881. /***********************************************************************
  882.         ２値化
  883. ***********************************************************************/
  884. void    SetMono()
  885. {
  886. int    i,l,m,x,y;
  887. int    om;
  888. UNchar    *M,*N;
  889. UNshort    *W;
  890. M=ScanData;
  891. x=ScanDataX;
  892. y=ScanDataY;
  893. _iocs_ms_sel2(mca2);
  894. om=_iocs_ms_curgt();
  895. if ( DataC!=0 ){
  896.     //===================== 24bit カラー記憶
  897.     for(l=0;l<ScanDataY;l++){
  898.         if ( DataMd==5 ){                // フルカラー
  899.             N=&M[ l*DataX*3 ];
  900.             for(i=0;i<ScanDataX;i++,N+=3){
  901.                 m=MonoColorDisp24(N[1]);
  902.                 N[0]= N[1]= N[2]=m;
  903.             }
  904.         } elif ( DataMd==2 ){            // グレイスケール
  905.             N=&M[ l*DataX ];
  906.             for(i=0;i<ScanDataX;i++,N++){
  907.                 *N=MonoColorDisp24(*N);
  908.             }
  909.         }
  910.         _iocs_ms_curst( DIVU(MULU(l,496),ScanDataY),512-16);
  911.     }
  912. } else {
  913.     //===================== 64k カラー記憶
  914.     for(l=0;l<ScanDataY;l++){
  915.         W=&M[ (l*DataX) *2 ];
  916.         for(i=0;i<ScanDataX;i++,W++)
  917.             *W=MonoColorDisp64(*W);
  918.         _iocs_ms_curst( DIVU(MULU(l,496),ScanDataY),512-16);
  919.     }
  920.  
  921. }
  922. MsPat(1);
  923. _iocs_ms_curst( om/0x10000,om&0xFFFF );
  924. }
  925. /***********************************************************************
  926.         グレイスケール化
  927. ***********************************************************************/
  928. void    SetGray()
  929. {
  930. int    i,l,m,x,y;
  931. int    om;
  932. UNchar    *M,*N;
  933. UNshort    *W;
  934. M=ScanData;
  935. x=ScanDataX;
  936. y=ScanDataY;
  937. _iocs_ms_sel2(mca2);
  938. om=_iocs_ms_curgt();
  939. if ( DataC!=0 ){
  940.     //===================== 24bit カラー記憶
  941.     for(l=0;l<ScanDataY;l++){
  942.         if ( DataMd==5 ){                // フルカラー
  943.             N=&M[ l*DataX*3 ];
  944.             for(i=0;i<ScanDataX;i++,N+=3){
  945.                 m=GrayColorDisp24(N[0],N[1],N[2]);
  946.                 N[0]= N[1]= N[2]=m;
  947.             }
  948.         } elif ( DataMd==2 ){            // グレイスケール
  949.             N=&M[ l*DataX ];
  950.             for(i=0;i<ScanDataX;i++,N++){
  951.                 *N=GrayColorDisp24(*N,*N,*N);
  952.             }
  953.         }
  954.         _iocs_ms_curst( DIVU(MULU(l,496),ScanDataY),512-16);
  955.     }
  956. } else {
  957.     //===================== 64k カラー記憶
  958.     for(l=0;l<ScanDataY;l++){
  959.         W=&M[ (l*DataX) *2 ];
  960.         for(i=0;i<ScanDataX;i++,W++)
  961.             *W=GrayColorDisp64(*W);
  962.         _iocs_ms_curst( DIVU(MULU(l,496),ScanDataY),512-16);
  963.     }
  964. }
  965. MsPat(1);
  966. _iocs_ms_curst( om/0x10000,om&0xFFFF );
  967. }
  968. /***********************************************************************
  969.         平滑化
  970. ***********************************************************************/
  971. void    SetDefocus()
  972. {
  973. if ( DataC!=0 ){
  974.     if ( DataMd==5 ){                // フルカラー
  975.         SetOthar(DefocusDisp24);
  976.     } else {
  977.         SetOthar(DefocusDisp24G);
  978.     }
  979. } else {
  980.     SetOthar(DefocusDisp64);
  981. }
  982. }
  983. /***********************************************************************
  984.         ﾒﾃﾞｨｱﾝ化
  985. ***********************************************************************/
  986. void    SetMedian()
  987. {
  988. if ( DataC!=0 ){
  989.     if ( DataMd==5 ){                // フルカラー
  990.         SetOthar(MedianDisp24);
  991.     } else {
  992.         SetOthar(MedianDisp24G);
  993.     }
  994. } else {
  995.     SetOthar(MedianDisp64);
  996. }
  997. }
  998. /***********************************************************************
  999.         鮮鋭化
  1000. ***********************************************************************/
  1001. void    SetSharp()
  1002. {
  1003. if ( DataC!=0 ){
  1004.     if ( DataMd==5 ){                // フルカラー
  1005.         SetOthar(SharpDisp24);
  1006.     } else {
  1007.         SetOthar(SharpDisp24G);
  1008.     }
  1009. } else {
  1010.     SetOthar(SharpDisp64);
  1011. }
  1012. }
  1013. /**************************************************
  1014.     汎用
  1015. ****************************************************/
  1016. void    SetOthar(sub)
  1017. int    (*sub)();
  1018. {
  1019. int    i,l,x,y;
  1020. int    om;
  1021. UNchar    *M,*N;
  1022. UNshort    *W;
  1023. _iocs_ms_sel2(mca2);
  1024. om=_iocs_ms_curgt();
  1025. M=ScanData;
  1026. x=ScanDataX;
  1027. y=ScanDataY;
  1028. if ( DataC!=0 ){
  1029.     //===================== 24bit カラー記憶
  1030.     if ( DataMd==5 ){                // フルカラー
  1031.         UNint    bf1[4096],bf2[4096];
  1032.         for(l=0;l<=ScanDataY;l++){
  1033.             if ( l<ScanDataY ){
  1034.                 for(i=0;i<ScanDataX;i++)
  1035.                     bf1[i]=sub(M,i,l);
  1036.             }
  1037.             if ( l>0 ){
  1038.                 N=&M[ MULU((l-1),DataX)*3 ];
  1039.                 for(i=0;i<ScanDataX;i++,N+=3){
  1040.                     N[0]=(bf2[i]/0x10000)&0xFF;
  1041.                     N[1]=(bf2[i]/0x100)  &0xFF;
  1042.                     N[2]= bf2[i]         &0xFF;
  1043.                     bf2[i]=bf1[i];
  1044.                 }
  1045.             } else {
  1046.                 for(i=0;i<ScanDataX;i++)
  1047.                     bf2[i]=bf1[i];
  1048.             }
  1049.             _iocs_ms_curst( DIVU(MULU(l,496),ScanDataY),512-16);
  1050.         }
  1051.     } elif ( DataMd==2 ){            // グレイスケール
  1052.         UNchar    bf1[4096],bf2[4096];
  1053.         for(l=0;l<=ScanDataY;l++){
  1054.             if ( l<ScanDataY ){
  1055.                 for(i=0;i<ScanDataX;i++)
  1056.                     bf1[i]=sub(M,i,l);
  1057.             }
  1058.             if ( l>0 ){
  1059.                 N=&M[ MULU((l-1),DataX) ];
  1060.                 for(i=0;i<ScanDataX;i++,N++){
  1061.                     N[0]=bf2[i];
  1062.                     bf2[i]=bf1[i];
  1063.                 }
  1064.             } else {
  1065.                 for(i=0;i<ScanDataX;i++)
  1066.                     bf2[i]=bf1[i];
  1067.             }
  1068.             _iocs_ms_curst( DIVU(MULU(l,496),ScanDataY),512-16);
  1069.         }
  1070.     }
  1071. } else {
  1072.     //===================== 64k カラー記憶
  1073.     UNshort    bf1[4096],bf2[4096];
  1074.     for(l=0;l<=ScanDataY;l++){
  1075.         if ( l<ScanDataY ){
  1076.             for(i=0;i<ScanDataX;i++)
  1077.                 bf1[i]=sub(M,i,l);
  1078.         }
  1079.         if ( l>0 ){
  1080.             W=&M[ MULU((l-1),DataX) *2 ];
  1081.             for(i=0;i<ScanDataX;i++){
  1082.                 *W++=bf2[i];
  1083.                 bf2[i]=bf1[i];
  1084.             }
  1085.         } else {
  1086.             for(i=0;i<ScanDataX;i++)
  1087.                 bf2[i]=bf1[i];
  1088.         }
  1089.         _iocs_ms_curst( DIVU(MULU(l,496),ScanDataY),512-16);
  1090.     }
  1091. }
  1092. MsPat(1);
  1093. _iocs_ms_curst( om/0x10000,om&0xFFFF );
  1094. }
  1095.